package plugin

import (
	"context"
	"fmt"
)

// ConnectorPlugin 连接器插件接口
type ConnectorPlugin interface {
	Plugin
	// Connect 建立连接
	Connect(ctx context.Context) error
	// Disconnect 断开连接
	Disconnect(ctx context.Context) error
	// Send 发送数据
	Send(ctx context.Context, data interface{}) error
	// Receive 接收数据
	Receive(ctx context.Context) (interface{}, error)
}

// BaseConnectorPlugin 基础连接器插件实现
type BaseConnectorPlugin struct {
	id          string
	version     string
	description string
	config      map[string]interface{}
	enabled     bool
	connected   bool
}

// NewBaseConnectorPlugin 创建新的基础连接器插件
func NewBaseConnectorPlugin(id, version, description string) *BaseConnectorPlugin {
	return &BaseConnectorPlugin{
		id:          id,
		version:     version,
		description: description,
		config:      make(map[string]interface{}),
		enabled:     false,
		connected:   false,
	}
}

// Initialize 初始化插件
func (p *BaseConnectorPlugin) Initialize(ctx context.Context, config map[string]interface{}) error {
	p.config = config
	return nil
}

// Start 启动插件
func (p *BaseConnectorPlugin) Start(ctx context.Context) error {
	p.enabled = true
	return nil
}

// Stop 停止插件
func (p *BaseConnectorPlugin) Stop(ctx context.Context) error {
	// 如果连接未断开，先断开连接
	if p.connected {
		if err := p.Disconnect(ctx); err != nil {
			return fmt.Errorf("failed to disconnect: %w", err)
		}
	}
	p.enabled = false
	return nil
}

// Connect 建立连接
func (p *BaseConnectorPlugin) Connect(ctx context.Context) error {
	if !p.enabled {
		return fmt.Errorf("plugin not started")
	}
	p.connected = true
	return nil
}

// Disconnect 断开连接
func (p *BaseConnectorPlugin) Disconnect(ctx context.Context) error {
	if !p.connected {
		return nil
	}
	p.connected = false
	return nil
}

// Send 发送数据 (基本实现，需要被子类覆盖)
func (p *BaseConnectorPlugin) Send(ctx context.Context, data interface{}) error {
	if !p.connected {
		return fmt.Errorf("not connected")
	}
	return fmt.Errorf("Send not implemented")
}

// Receive 接收数据 (基本实现，需要被子类覆盖)
func (p *BaseConnectorPlugin) Receive(ctx context.Context) (interface{}, error) {
	if !p.connected {
		return nil, fmt.Errorf("not connected")
	}
	return nil, fmt.Errorf("Receive not implemented")
}

// GetType 获取插件类型
func (p *BaseConnectorPlugin) GetType() PluginType {
	return PluginTypeConnector
}

// GetID 获取插件ID
func (p *BaseConnectorPlugin) GetID() string {
	return p.id
}

// GetVersion 获取插件版本
func (p *BaseConnectorPlugin) GetVersion() string {
	return p.version
}

// GetDescription 获取插件描述
func (p *BaseConnectorPlugin) GetDescription() string {
	return p.description
}

// GetInfo 返回插件信息
func (p *BaseConnectorPlugin) GetInfo() PluginInfo {
	return PluginInfo{
		ID:          p.id,
		Name:        p.id,
		Type:        PluginTypeConnector,
		Mode:        PluginModeRPC, // 默认为RPC模式
		Version:     p.version,
		APIVersion:  1,
		Author:      "DataLink",
		Description: p.description,
		License:     "",
		Homepage:    "",
		Config:      p.config,
	}
}

// TCPConnectorPlugin TCP连接器插件示例
type TCPConnectorPlugin struct {
	*BaseConnectorPlugin
	host string
	port int
}

// NewTCPConnectorPlugin 创建新的TCP连接器插件
func NewTCPConnectorPlugin(id, version, description string) *TCPConnectorPlugin {
	return &TCPConnectorPlugin{
		BaseConnectorPlugin: NewBaseConnectorPlugin(id, version, description),
		host:                "localhost",
		port:                8080,
	}
}

// Initialize 初始化插件
func (p *TCPConnectorPlugin) Initialize(ctx context.Context, config map[string]interface{}) error {
	if err := p.BaseConnectorPlugin.Initialize(ctx, config); err != nil {
		return err
	}

	// 解析配置
	if host, ok := config["host"].(string); ok {
		p.host = host
	}
	if port, ok := config["port"].(float64); ok {
		p.port = int(port)
	}

	return nil
}

// Connect 建立TCP连接
func (p *TCPConnectorPlugin) Connect(ctx context.Context) error {
	if err := p.BaseConnectorPlugin.Connect(ctx); err != nil {
		return err
	}

	// 模拟建立TCP连接
	fmt.Printf("Connecting to TCP server at %s:%d\n", p.host, p.port)
	// 实际实现中应该建立真正的TCP连接
	// conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", p.host, p.port))
	// if err != nil {
	//     return fmt.Errorf("failed to connect to TCP server: %w", err)
	// }
	// p.conn = conn

	return nil
}

// Disconnect 断开TCP连接
func (p *TCPConnectorPlugin) Disconnect(ctx context.Context) error {
	if err := p.BaseConnectorPlugin.Disconnect(ctx); err != nil {
		return err
	}

	// 模拟断开TCP连接
	fmt.Printf("Disconnecting from TCP server at %s:%d\n", p.host, p.port)
	// 实际实现中应该关闭连接
	// if p.conn != nil {
	//     p.conn.Close()
	//     p.conn = nil
	// }

	return nil
}

// Send 通过TCP发送数据
func (p *TCPConnectorPlugin) Send(ctx context.Context, data interface{}) error {
	if !p.connected {
		return fmt.Errorf("not connected")
	}

	// 模拟发送数据
	fmt.Printf("Sending data to TCP server at %s:%d: %v\n", p.host, p.port, data)
	// 实际实现中应该使用连接发送数据
	// dataBytes, err := json.Marshal(data)
	// if err != nil {
	//     return fmt.Errorf("failed to serialize data: %w", err)
	// }
	//
	// _, err = p.conn.Write(dataBytes)
	// if err != nil {
	//     return fmt.Errorf("failed to send data: %w", err)
	// }

	return nil
}

// Receive 从TCP接收数据
func (p *TCPConnectorPlugin) Receive(ctx context.Context) (interface{}, error) {
	if !p.connected {
		return nil, fmt.Errorf("not connected")
	}

	// 模拟接收数据
	fmt.Printf("Receiving data from TCP server at %s:%d\n", p.host, p.port)
	// 实际实现中应该从连接接收数据
	// buffer := make([]byte, 1024)
	// n, err := p.conn.Read(buffer)
	// if err != nil {
	//     return nil, fmt.Errorf("failed to receive data: %w", err)
	// }
	//
	// var result interface{}
	// if err := json.Unmarshal(buffer[:n], &result); err != nil {
	//     return nil, fmt.Errorf("failed to deserialize data: %w", err)
	// }

	// 返回模拟数据
	return map[string]interface{}{
		"status": "ok",
		"data":   "This is a simulated response",
	}, nil
}
